#!/usr/bin/python
# -*- coding: utf-8 -*-

import sys, os
import Ice

SLICE = os.path.join('..', '..', 'slice')
FILE1 = os.path.join(SLICE, 'Oculus.ice')
Ice.loadSlice('--all -I/usr/share/slice', ['-I' + SLICE, FILE1])

import Oculus

class PedestrianCrossing:

    def __init__ (self, id, crossing_area, road_area_1, road_area_2, sidewalk_1, sidewalk_2):

        # Identificador del paso de peatones.
        self._id = id
        # Área que comprender el paso de peatones.
        self._crossing_area = crossing_area
        # Trozos de la calzada adyacentes al paso.
        self._road_area_1, self.__road_area_2 = road_area_1, road_area_2
        # Aceras adyacentes al paso.
        self._sidewalk_1, self.__sidewalk_2 = sidewalk_1, sidewalk_2

    # Devuelve la lista de zonas pertenecientes al paso
    # sobre las que se encuentra un objeto.
    # degree se usa como umbral.
    def is_over (self, object_info_event, degree = 0.0):

        zones = []

        for loc in object_info_event.locations:
            if loc.zone == self._crossing_area and loc.belief > degree:
                zones.append(Oculus.Location(loc.zone, loc.belief))
            if loc.zone == self._road_area1 and loc.belief > degree:
                zones.append(Oculus.Location(loc.zone, loc.belief))
            if loc.zone == self._road_area2 and loc.belief > degree:
                zones.append(Oculus.Location(loc.zone, loc.belief))
            if loc.zone == self._sidewalk_1 and loc.belief > degree:
                zones.append(Oculus.Location(loc.zone, loc.belief))
            if loc.zone == self._sidewalk_2 and loc.belief > degree:
                zones.append(Oculus.Location(loc.zone, loc.belief))

        return zones

class PedestrianCrossingAnalysis:

    def __init__ (self, pedestrian_crossing):

        # Suponemos un paso de peatones por agente de normalidad.
        self._pedestrian_crossing = pedestrian_crossing

    # Devuelve el grado de normalidad de cada vehículo detectado en la escena.
    # object_info_events --> información de los objetos.
    # role_belief_threshold --> umbral para establecer cuándo un objeto se
    # entiende como peatón o vehículo.
    def analysis (self, object_info_events = [], role_belief_threshold = 0.5):

        vehicles_normality = {}

        for oie in object_info_events:
            for role in oie.roles:
                # Suponemos coche.
                if role.actor == 'vehicle' and role.belief > role_belief_threshold:
                    # Cerca o sobre el paso?
                    vehicle_spatial_degree = 0.0
                    p = self._pedestrian_crossing
                    zones = p.is_over(oie)
                    for z in zones:
                        if (z.zone == p._road_area_1) or (z.zone == p._road_area_2) or (z.zone == p._crossing_area):
                            if z.belief > vehicle_spatial_degree:
                                vehicle_spatial_degree = z.belief
                                # Tenemos en cuenta todos los vehículos que cumplen estas condiciones.
                                # Por cada vehículo, almacenamos el mayor grado de 'posicionamiento'
                                # respecto a las 'zonas' sobre y 'cerca' del paso.
                                vehicles_normality[obj.id] = vehicle_spatial_degree

        # Hay peatones esperando o sobre el paso?

        # Algún vehículo cerca o sobre el paso?
        if len(vehicles_normality) > 0:
            # Aquí se almacena el grado del peatón más cercano respecto al paso.
            pedestrian_spatial_degree = 0.0
            for oie in object_info_events:
                for role in oie.roles:
                    # Suponemos peatón.
                    if role.actor == 'pedestrian' and role.belief > role_belief_threshold:
                        zones = p.is_over(oie)
                        for z in zones:
                            if (z.zone == p._sidewalk_1) or (z.zone == p._sidewalk_2) or (z.zone == p._crossing_area):
                                if z.belief > pedestrian_spatial_degree:
                                    pedestrian_spatial_degree = z.belief

        # TODO: obtener el grado de normalidad en función de la posición de vehículo y peatón.
        # ENTRADA: pedestrian_spatial_degree
        # ENTRADA: vehicles_normality
        # SALIDA: actualización de vehicles_normality

        return vehicles_normality                                           
